/*
package com.baojee.index.config;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.baojee.index.utils.JedisUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import redis.clients.jedis.*;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException;

import redis.clients.util.Pool;

import javax.annotation.Resource;


*/
/**
 * JedisTemplate 提供了一个template方法，负责对Jedis连接的获取与归还。 JedisAction<T> 和
 * JedisActionNoResult两种回调接口，适用于有无返回值两种情况。 PipelineAction 与
 * PipelineActionResult两种接口，适合于pipeline中批量传输命令的情况。
 * <p>
 * 同时提供一些JedisOperation中定义的 最常用函数的封装, 如get/set/zadd等。
 *//*

@Component
public class ShardedJedisTemplate {

    private static Logger logger = LoggerFactory.getLogger(ShardedJedisTemplate.class);


    private Pool<ShardedJedis> shardedJedislPool;


    public ShardedJedisTemplate() {
    }

    public ShardedJedisTemplate(Pool<ShardedJedis> shardedJedislPool) {

        this.shardedJedislPool = shardedJedislPool;
    }

    public String getAsList(String key) {
        String value = get(key);
        if (null != value && !value.equals("[]")) {
            return value;
        } else {
            return null;
        }
    }

    */
/**
     * Callback interface for template.
     *//*

    public interface JedisAction<T> {

        T action(ShardedJedis jedis);
    }

    */
/**
     * Callback interface for template without result.
     *//*

    public interface JedisActionNoResult {

        void action(ShardedJedis jedis);
    }

    */
/**
     * Callback interface for template.
     *//*

    public interface PipelineAction {

        List<Object> action(ShardedJedisPipeline Pipeline);
    }

    */
/**
     * Callback interface for template without result.
     *//*

    public interface PipelineActionNoResult {

        void action(ShardedJedisPipeline Pipeline);
    }

    */
/**
     * Execute with a call back action with result.
     *//*

    public <T> T execute(JedisAction<T> jedisAction) throws JedisException {
        ShardedJedis jedis = null;
        boolean broken = false;
        try {
            jedis = shardedJedislPool.getResource();
            return jedisAction.action(jedis);
        } catch (JedisException e) {
            broken = handleJedisException(e);
            throw e;
        } finally {
            closeResource(jedis, broken);
        }
    }

    */
/**
     * Execute with a call back action without result.
     *//*

    public void execute(JedisActionNoResult jedisAction) throws JedisException {
        ShardedJedis jedis = null;
        boolean broken = false;
        try {
            jedis = shardedJedislPool.getResource();
            jedisAction.action(jedis);
        } catch (JedisException e) {
            broken = handleJedisException(e);
            throw e;
        } finally {
            closeResource(jedis, broken);
        }
    }

    */
/**
     * Execute with a call back action with result in pipeline.
     *//*

    public List<Object> execute(PipelineAction pipelineAction) throws JedisException {
        ShardedJedis jedis = null;
        boolean broken = false;
        try {
            jedis = shardedJedislPool.getResource();
            ShardedJedisPipeline pipeline = jedis.pipelined();
            pipelineAction.action(pipeline);
            return pipeline.syncAndReturnAll();
        } catch (JedisException e) {
            broken = handleJedisException(e);
            throw e;
        } finally {
            closeResource(jedis, broken);
        }
    }

    */
/**
     * Execute with a call back action without result in pipeline.
     *//*

    public void execute(PipelineActionNoResult pipelineAction) throws JedisException {
        ShardedJedis jedis = null;
        boolean broken = false;
        try {
            jedis = shardedJedislPool.getResource();
            ShardedJedisPipeline pipeline = jedis.pipelined();
            pipelineAction.action(pipeline);
            pipeline.sync();
        } catch (JedisException e) {
            broken = handleJedisException(e);
            throw e;
        } finally {
            closeResource(jedis, broken);
        }
    }

    */
/**
     * Return the internal JedisPool.
     *//*

    public Pool<ShardedJedis> getJedisPool() {
        return shardedJedislPool;
    }

    */
/**
     * Handle jedisException, write log and return whether the connection is broken.
     *//*

    protected boolean handleJedisException(JedisException jedisException) {
        if (jedisException instanceof JedisConnectionException) {
            logger.error("Redis connection  lost.", jedisException);
        } else if (jedisException instanceof JedisDataException) {
            if ((jedisException.getMessage() != null) && (jedisException.getMessage().indexOf("READONLY") != -1)) {
                logger.error("Redis connection  are read-only slave.", jedisException);
            } else {
                // dataException, isBroken=false
                return false;
            }
        } else {
            logger.error("Jedis exception happen.", jedisException);
        }
        return true;
    }

    */
/**
     * Return jedis connection to the pool, call different return methods depends on the
     * conectionBroken status.
     *//*

    protected void closeResource(ShardedJedis jedis, boolean conectionBroken) {
        try {
            if (conectionBroken) {
                shardedJedislPool.returnBrokenResource(jedis);
            } else {
                shardedJedislPool.returnResource(jedis);
            }
        } catch (Exception e) {
            logger.error("return back jedis failed, will fore close the jedis.", e);
            JedisUtils.destroyShardedJedis(jedis);
        }

    }

    public String getHost(ShardedJedis jedis, String key) {
        JedisShardInfo shard = jedis.getShardInfo(key);
        return shard.getHost() + ":" + shard.getPort();
    }

    // / Common Actions ///

    */
/**
     * 删除key, 如果key存在返回true, 否则返回false。
     *//*

    public Boolean del(final String keys) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.del(keys) == 1 ? true : false;
            }
        });
    }

    public Boolean del(final byte[] keys) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.del(keys) == 1 ? true : false;
            }
        });
    }

    // / String Actions ///

    */
/**
     * 如果key不存在, 返回null.
     *//*

    public String get(final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                return jedis.get(key);
            }
        });
    }

    public byte[] get(final byte[] key) {
        return execute(new JedisAction<byte[]>() {

            @Override
            public byte[] action(ShardedJedis jedis) {
                return jedis.get(key);
            }
        });
    }

    */
/**
     * Get the value of the specified key as Long.If the key does not exist null is returned.
     *//*

    public Long getAsLong(final String key) {
        String result = get(key);
        return result != null ? Long.valueOf(result) : null;
    }

    */
/**
     * Get the value of the specified key as Integer.If the key does not exist null is returned.
     *//*

    public Integer getAsInt(final String key) {
        String result = get(key);
        return result != null ? Integer.valueOf(result) : null;
    }

    */
/**
     * 方法功能说明：添加一个缓存对象
     *
     * @param key
     * @param value
     * @return void 方法名称: set
     *//*

    public void set(final byte[] key, final byte[] value) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.set(key, value);
            }
        });
    }

    */
/**
     * 方法功能说明：添加一个缓存对象
     *
     * @param key
     * @param value
     * @return void 方法名称: set
     *//*

    public void set(final String key, final String value) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.set(key, value);
            }
        });
    }

    */
/**
     * 方法功能说明：添加缓存对象,并设置过期时间
     *
     * @param key
     * @param value
     * @param seconds
     * @return void 方法名称: set
     *//*

    public void setex(final String key, final String value, final int seconds) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.setex(key, seconds, value);
            }
        });
    }

    public void setex(final byte[] key, final byte[] value, final int seconds) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.setex(key, seconds, value);
            }
        });
    }

    */
/**
     * 方法功能说明：如果key不存在则添加缓存对象并返回true,存在则不添加并返回false
     *
     * @param key
     * @param value
     * @return boolean 方法名称: setnx
     *//*

    public Boolean setnx(final String key, final String value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.setnx(key, value) == 1 ? true : false;
            }
        });
    }

    */
/**
     * The command is exactly equivalent to the following group of commands:
     * {@link #setex(String, String, int) SETEX} +
     *//*

    public Boolean setnxex(final String key, final String value, final int seconds) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                String result = jedis.set(key, value, "NX", "EX", seconds);
                return JedisUtils.isStatusOk(result);
            }
        });
    }

    */
/**
     * 方法功能说明：自动将key对应到value并且返回原来key对应的value。
     *
     * @param key
     * @param value
     * @return String 方法名称: getSet
     *//*

    public String getSet(final String key, final String value) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                return jedis.getSet(key, value);
            }
        });
    }

    */
/**
     * 方法功能说明：返回key的string类型value的长度
     *
     * @param key
     * @return long 方法名称: strlen
     *//*

    public long strlen(final String key) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.strlen(key);
            }
        });
    }

    */
/**
     * Increment the number stored at key by one. If the key does not exist or contains a value of a
     * wrong type, set the key to the value of "0" before to perform the increment operation.
     * <p>
     * INCR commands are limited to 64 bit signed integers.
     * <p>
     * Note: this is actually a string operation, that is, in Redis there are not "integer" types.
     * Simply the string stored at the key is parsed as a base 10 64 bit signed integer,
     * incremented, and then converted back as a string.
     *
     * @return Integer reply, this commands will reply with the new value of key after the
     * increment.
     *//*

    public Long incr(final String key) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.incr(key);
            }
        });
    }

    public Long incrBy(final String key, final long increment) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.incrBy(key, increment);
            }
        });
    }

    public Double incrByFloat(final String key, final double increment) {
        return execute(new JedisAction<Double>() {
            @Override
            public Double action(ShardedJedis jedis) {
                return jedis.incrByFloat(key, increment);
            }
        });
    }

    */
/**
     * Decrement the number stored at key by one. If the key does not exist or contains a value of a
     * wrong type, set the key to the value of "0" before to perform the decrement operation.
     *//*

    public Long decr(final String key) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.decr(key);
            }
        });
    }

    public Long decrBy(final String key, final long decrement) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.decrBy(key, decrement);
            }
        });
    }

    // / Hash Actions ///

    public String hget(final String key, final String fieldName) {
        return execute(new JedisAction<String>() {
            @Override
            public String action(ShardedJedis jedis) {
                return jedis.hget(key, fieldName);
            }
        });
    }

    public byte[] hget(final byte[] key, final byte[] fieldName) {
        return execute(new JedisAction<byte[]>() {
            @Override
            public byte[] action(ShardedJedis jedis) {
                return jedis.hget(key, fieldName);
            }
        });
    }

    */
/**
     * 方法功能说明：根据key获取指定fields属性的值
     *
     * @param key
     * @param fieldsNames
     * @return String 方法名称: hmget
     *//*

    public List<String> hmget(final String key, final String... fieldsNames) {
        return execute(new JedisAction<List<String>>() {
            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.hmget(key, fieldsNames);
            }
        });
    }

    */
/**
     * 方法功能说明：根据key获取缓存对象
     *
     * @param key
     * @return String 方法名称: hgetAll
     *//*

    public Map<String, String> hgetAll(final String key) {
        return execute(new JedisAction<Map<String, String>>() {
            @Override
            public Map<String, String> action(ShardedJedis jedis) {
                return jedis.hgetAll(key);
            }
        });
    }

    public Map<byte[], byte[]> hgetAll(final byte[] key) {
        return execute(new JedisAction<Map<byte[], byte[]>>() {
            @Override
            public Map<byte[], byte[]> action(ShardedJedis jedis) {
                return jedis.hgetAll(key);
            }
        });
    }

    */
/**
     * 方法功能说明：设置 key 指定的哈希集中指定字段的值。如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key 关联。如果字段在哈希集中存在，它将被重写。
     *
     * @param key
     * @param fieldName
     * @param value
     * @return void 方法名称: hset
     *//*

    public void hset(final String key, final String fieldName, final String value) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.hset(key, fieldName, value);
            }
        });
    }

    public void hset(final byte[] key, final byte[] fieldName, final byte[] value) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.hset(key, fieldName, value);
            }
        });
    }

    */
/**
     * 方法功能说明：设置 key 指定的哈希集中指定字段的值。该命令将重写所有在哈希集中存在的字段。如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key 关联
     *
     * @param key
     * @param map
     * @return boolean 方法名称: hmset
     *//*

    public void hmset(final String key, final Map<String, String> map) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.hmset(key, map);
            }
        });
    }

    public void hmset(final byte[] key, final Map<byte[], byte[]> map) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(ShardedJedis jedis) {
                jedis.hmset(key, map);
            }
        });
    }

    */
/**
     * 方法功能说明：只在 key 指定的哈希集中不存在指定的字段时，设置字段的值。如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key 关联。如果字段已存在，该操作无效果。
     *
     * @param key
     * @param fieldName
     * @param value
     * @return void 方法名称: hset
     *//*

    public Boolean hsetnx(final String key, final String fieldName, final String value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.hsetnx(key, fieldName, value) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：增加 key 指定的哈希集中指定字段的数值。如果 key 不存在，会创建一个新的哈希集并与 key 关联。如果字段不存在，则字段的值在该操作执行前被设置为 0
     *
     * @param key
     * @param fieldName
     * @param increment
     * @return long 方法名称: hincrby
     *//*

    public Long hincrBy(final String key, final String fieldName, final long increment) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.hincrBy(key, fieldName, increment);
            }
        });
    }

    public Double hincrByFloat(final String key, final String fieldName, final double increment) {
        return execute(new JedisAction<Double>() {
            @Override
            public Double action(ShardedJedis jedis) {
                return jedis.hincrByFloat(key, fieldName, increment);
            }
        });
    }

    */
/**
     * 方法功能说明：从 key 指定的哈希集中移除指定的域。在哈希集中不存在的域将被忽略。如果 key 指定的哈希集不存在，它将被认为是一个空的哈希集，该命令将返回0。
     *
     * @param key
     * @param fieldsNames
     * @return boolean 方法名称: hdel
     *//*

    public Long hdel(final String key, final String... fieldsNames) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.hdel(key, fieldsNames);
            }
        });
    }

    public Long hdel(final byte[] key, final byte[] fieldsNames) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.hdel(key, fieldsNames);
            }
        });
    }

    */
/**
     * 方法功能说明：判断给定字段是否存在于哈希集中
     *
     * @param key
     * @param fieldName
     * @return String 方法名称: hkeys
     *//*

    public Boolean hexists(final String key, final String fieldName) {
        return execute(new JedisAction<Boolean>() {
            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.hexists(key, fieldName);
            }
        });
    }

    */
/**
     * 方法功能说明：返回 key 指定的哈希集中所有字段名称。
     *
     * @param key
     * @return String 方法名称: hgetAll
     *//*

    public Set<String> hkeys(final String key) {
        return execute(new JedisAction<Set<String>>() {
            @Override
            public Set<String> action(ShardedJedis jedis) {
                return jedis.hkeys(key);
            }
        });
    }

    public Set<byte[]> hkeys(final byte[] key) {
        return execute(new JedisAction<Set<byte[]>>() {
            @Override
            public Set<byte[]> action(ShardedJedis jedis) {
                return jedis.hkeys(key);
            }
        });
    }

    */
/**
     * 方法功能说明：返回 key 指定的哈希集中所有字段的值。
     *
     * @param key
     * @return String 方法名称: hvals
     *//*

    public List<String> hvals(final String key) {
        return execute(new JedisAction<List<String>>() {

            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.hvals(key);
            }
        });
    }

    public Collection<byte[]> hvals(final byte[] key) {
        return execute(new JedisAction<Collection<byte[]>>() {

            @Override
            public Collection<byte[]> action(ShardedJedis jedis) {
                return jedis.hvals(key);
            }
        });
    }

    public Long hlen(final String key) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.hlen(key);
            }
        });
    }

    public Long hlen(final byte[] key) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.hlen(key);
            }
        });
    }

    // / List Actions ///

    */
/**
     * 方法功能说明：从list头部插入数据
     *
     * @param key
     * @param values
     * @return void 方法名称: lpush
     *//*

    public Long lpush(final String key, final String... values) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.lpush(key, values);
            }
        });
    }

    */
/**
     * 方法功能说明：当 key 已经存在并且存着一个 list 的时候，在 list的头部插入 value
     *
     * @param key
     * @param value
     * @return boolean 方法名称: lpushx
     *//*

    public boolean lpushx(final String key, final String... value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.lpushx(key, value) > 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：从list尾部插入数据
     *
     * @param key
     * @param value
     * @return void 方法名称: lpush
     *//*

    public boolean rpush(final String key, final String... value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.rpush(key, value) > 0 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：当 key 已经存在并且存着一个 list 的时候，在 list的尾部插入 value
     *
     * @param key
     * @param value
     * @return boolean 方法名称: lpushx
     *//*

    public boolean rpushx(final String key, final String... value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.rpushx(key, value) > 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：从队列左边取出一个数据
     *
     * @param key
     * @return String 方法名称: lpop
     *//*

    public String lpop(final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                return jedis.lpop(key);
            }
        });
    }

    */
/**
     * 方法功能说明：从队列右边取出一个数据
     *
     * @param key
     * @return String 方法名称: rpop
     *//*

    public String rpop(final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                return jedis.rpop(key);
            }
        });
    }

    */
/**
     * 方法功能说明：在某个元素前面插入一个新元素
     *
     * @param key
     * @param pivot list中存在的元素
     * @param value 新插入元素
     * @return boolean 方法名称: linsertBefore
     *//*

    public boolean linsertBefore(final String key, final String pivot, final String value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.linsert(key, BinaryClient.LIST_POSITION.BEFORE, pivot, value) > 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：在某个元素后面插入一个新元素
     *
     * @param key
     * @param pivot list中存在的元素
     * @param value 新插入元素
     * @return boolean 方法名称: linsertBefore
     *//*

    public boolean linsertAfter(final String key, final String pivot, final String value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.linsert(key, BinaryClient.LIST_POSITION.AFTER, pivot, value) > 1 ? true : false;
            }
        });
    }

    public String brpop(final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                List<String> nameValuePair = jedis.brpop(key);
                if (nameValuePair != null) {
                    return nameValuePair.get(1);
                } else {
                    return null;
                }
            }
        });
    }

    public String brpop(final int timeout, final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                List<String> nameValuePair = jedis.brpop(timeout, key);
                if (nameValuePair != null) {
                    return nameValuePair.get(1);
                } else {
                    return null;
                }
            }
        });
    }

    */
/**
     * 方法功能说明：获取list所有值
     *
     * @param key
     * @return List<String> 方法名称: lrangeAll
     *//*

    public List<String> lgetAll(final String key) {
        return lget(key, 0, -1);
    }

    */
/**
     * 方法功能说明：返回存储在 key 的列表里指定范围内的元素。即list的第一个元素下标是0（list的表头），以此类推。偏移量也可以是负数，表示偏移量是从list尾部开始计数。 例如，
     * -1 表示列表的最后一个元素，-2 是倒数第二个，以此类推。
     *
     * @param key
     * @param start 起始位置
     * @param end   结束位置
     * @return List<String> 方法名称: lrange
     *//*

    public List<String> lget(final String key, final long start, final long end) {
        return execute(new JedisAction<List<String>>() {

            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.lrange(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：修改list指定索引位置的值
     *
     * @param key
     * @param index 索引位置
     * @param value
     * @return boolean 方法名称: lset
     *//*

    public boolean lset(final String key, final long index, final String value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.lset(key, index, value).equalsIgnoreCase("OK");
            }
        });
    }

    */
/**
     * 方法功能说明：返回List长度, key不存在时返回0，key类型不是list时抛出异常.
     *
     * @param key
     * @return long 方法名称: llen
     *//*

    public Long llen(final String key) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.llen(key);
            }
        });
    }

    */
/**
     * 方法功能说明：返回list中,指定索引位置的数据.即list的第一个元素下标是0（list的表头），以此类推。偏移量也可以是负数， 表示偏移量是从list尾部开始计数。 例如， -1
     * 表示列表的最后一个元素，-2 是倒数第二个，以此类推。
     *
     * @param key
     * @param index
     * @return String 方法名称: lindex
     *//*

    public String lindex(final String key, final long index) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                return jedis.lindex(key, index);
            }
        });
    }

    public List<String> lrange(final String key, final int start, final int end) {
        return execute(new JedisAction<List<String>>() {

            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.lrange(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：list截取操作,删除指定索引位置范围以外的数据。即list的第一个元素下标是0（list的表头），以此类推。偏移量也可以是负数， 表示偏移量是从list尾部开始计数。
     * 例如， -1 表示列表的最后一个元素，-2 是倒数第二个，以此类推。
     *
     * @param key
     * @param start 索引开始位置
     * @param end   索引结束位置
     * @return String 方法名称: ltrim
     *//*

    public void ltrim(final String key, final int start, final int end) {
        execute(new JedisActionNoResult() {
            @Override
            public void action(ShardedJedis jedis) {
                jedis.ltrim(key, start, end);
            }
        });
    }

    public void ltrimFromLeft(final String key, final int size) {
        execute(new JedisActionNoResult() {
            @Override
            public void action(ShardedJedis jedis) {
                jedis.ltrim(key, 0, size - 1);
            }
        });
    }

    public Boolean lremFirst(final String key, final String value) {
        return execute(new JedisAction<Boolean>() {
            @Override
            public Boolean action(ShardedJedis jedis) {
                Long count = jedis.lrem(key, 1, value);
                return (count == 1);
            }
        });
    }

    */
/**
     * 方法功能说明：移除list列表前 count次出现的值为 value 的元素。 count > 0: 从头往尾移除值为 value 的元素。 count < 0: 从尾往头移除值为
     * value 的元素。 count = 0: 移除所有值为 value 的元素。
     *
     * @param key
     * @param count
     * @param value
     * @return long 方法名称: lrem
     *//*

    public long lrem(final String key, final long count, final String value) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.lrem(key, count, value);
            }
        });
    }

    public Boolean lremAll(final String key, final String value) {
        return execute(new JedisAction<Boolean>() {
            @Override
            public Boolean action(ShardedJedis jedis) {
                Long count = jedis.lrem(key, 0, value);
                return (count > 0);
            }
        });
    }

    // / Set Actions ///

    */
/**
     * 方法功能说明：集合中添加元素,不可重复
     *
     * @param key
     * @param member
     * @return void 方法名称: sadd
     *//*

    public Boolean sadd(final String key, final String member) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.sadd(key, member) == 1 ? true : false;
            }
        });
    }

    public Boolean sadd(final byte[] key, final byte[] member) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.sadd(key, member) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：获取集合中所有元素
     *
     * @param key
     * @return Set<String> 方法名称: sget
     *//*

    public Set<String> sget(final String key) {
        return execute(new JedisAction<Set<String>>() {

            @Override
            public Set<String> action(ShardedJedis jedis) {
                return jedis.smembers(key);
            }
        });
    }

    public Set<byte[]> sget(final byte[] key) {
        return execute(new JedisAction<Set<byte[]>>() {

            @Override
            public Set<byte[]> action(ShardedJedis jedis) {
                return jedis.smembers(key);
            }
        });
    }

    */
/**
     * 方法功能说明：从集合中随机获取元素
     *
     * @param key   集合key
     * @param count 数量
     * @return
     *//*

    public List<String> srandget(final String key, final int count) {
        return execute(new JedisAction<List<String>>() {
            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.srandmember(key, count);
            }
        });
    }

    public List<String> srandget(final byte[] key, final int count) {
        return execute(new JedisAction<List<String>>() {
            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.srandmember(key, count);
            }
        });
    }

    */
/**
     * 方法功能说明：获取集合元素数量
     *
     * @param key
     * @return long 方法名称: slen
     *//*

    public long slen(final String key) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.scard(key);
            }
        });
    }

    */
/**
     * 方法功能说明：删除集合中指定元素
     *
     * @param key
     * @param values
     * @return boolean 方法名称: sdel
     *//*

    public boolean sdel(final String key, final String... values) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.srem(key, values) > 0 ? true : false;
            }
        });
    }

    public boolean sdel(final byte[] key, final byte[]... values) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.srem(key, values) > 0 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：返回成员 member 是否是存储的集合 key的成员
     *
     * @param key
     * @param value
     * @return boolean 方法名称: sexists
     *//*

    public boolean sexists(final String key, final String value) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.sismember(key, value);
            }
        });
    }

    // / Ordered Set Actions ///

    */
/**
     * 方法功能说明：加入Sorted set, 如果member在Set里已存在，只更新score并返回false,否则返回true
     *
     * @param key
     * @param member
     * @param score
     * @return boolean 方法名称: zadd
     *//*

    public Boolean zadd(final String key, final double score, final String member) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.zadd(key, score, member) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：为有序集key的成员member的score值加上增量increment。如果key中不存在member， 就在key中添加一个member
     * ，score是increment。如果key不存在，就创建一个只含有指定member成员的有序集合。
     *
     * @param key
     * @param score
     * @param member
     * @return double 方法名称: zincrby
     *//*

    public double zincrby(final String key, final double score, final String member) {
        return execute(new JedisAction<Double>() {

            @Override
            public Double action(ShardedJedis jedis) {
                return jedis.zincrby(key, score, member);
            }
        });
    }

    */
/**
     * 方法功能说明：返回有序集key中，成员member的score值。
     *
     * @param key
     * @param member
     * @return double 方法名称: zgetScore
     *//*

    public Double zscore(final String key, final String member) {
        return execute(new JedisAction<Double>() {

            @Override
            public Double action(ShardedJedis jedis) {
                return jedis.zscore(key, member);
            }
        });
    }

    public Long zrank(final String key, final String member) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.zrank(key, member);
            }
        });
    }

    public Long zrevrank(final String key, final String member) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.zrevrank(key, member);
            }
        });
    }

    */
/**
     * 方法功能说明：返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员数量。
     *
     * @param key
     * @param min
     * @param max
     * @return long 方法名称: zcount
     *//*

    public Long zcount(final String key, final double min, final double max) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.zcount(key, min, max);
            }
        });
    }

    */
/**
     * 方法功能说明： 返回有序集key中，指定区间内的成员。其中成员按score值递增(从小到大)来排序。具有相同score值的成员按字典序来排列。
     * <p>
     * 下标参数start和stop都以0为底，也就是说，以0表示有序集第一个成员，以1表示有序集第二个成员，以此类推。
     * 你也可以使用负数下标，以-1表示最后一个成员，-2表示倒数第二个成员，以此类推。
     *
     * @param key
     * @param start
     * @param end
     * @return Set<String> 方法名称: zget
     *//*

    public Set<String> zrange(final String key, final int start, final int end) {
        return execute(new JedisAction<Set<String>>() {

            @Override
            public Set<String> action(ShardedJedis jedis) {
                return jedis.zrange(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：返回有序集key中，指定区间内的成员和score值。其中成员按score值递增(从小到大)来排序。 具有相同score值的成员按字典序来排列。
     *
     * @param key
     * @param start
     * @param end
     * @return Set<Tuple> 方法名称: zgetWithScores
     *//*

    public Set<Tuple> zrangeWithScores(final String key, final int start, final int end) {
        return execute(new JedisAction<Set<Tuple>>() {

            @Override
            public Set<Tuple> action(ShardedJedis jedis) {
                return jedis.zrangeWithScores(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：返回有序集key中，指定区间内的成员。其中成员的位置按score值递减(从大到小)来排列。
     *
     * @param key
     * @param start
     * @param end
     * @return Set<String> 方法名称: zrevget
     *//*

    public Set<String> zrevrange(final String key, final int start, final int end) {
        return execute(new JedisAction<Set<String>>() {

            @Override
            public Set<String> action(ShardedJedis jedis) {
                return jedis.zrevrange(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：返回有序集key中，指定区间内的成员和score值。其中成员的位置按score值递减(从大到小)来排列。
     *
     * @param key
     * @param start
     * @param end
     * @return Set<Tuple> 方法名称: zrevgetWithScores
     *//*

    public Set<Tuple> zrevrangeWithScores(final String key, final int start, final int end) {
        return execute(new JedisAction<Set<Tuple>>() {

            @Override
            public Set<Tuple> action(ShardedJedis jedis) {
                return jedis.zrevrangeWithScores(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素是从低分到高分排序的。
     *
     * @param key
     * @param min
     * @param max
     * @return Set<String> 方法名称: zgetByScore
     *//*

    public Set<String> zrangeByScore(final String key, final double min, final double max) {
        return execute(new JedisAction<Set<String>>() {

            @Override
            public Set<String> action(ShardedJedis jedis) {
                return jedis.zrangeByScore(key, min, max);
            }
        });
    }

    */
/**
     * 方法功能说明：返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）以及score值。 元素是从低分到高分排序的。
     *
     * @param key
     * @param min
     * @param max
     * @return Set<String> 方法名称: zgetByScoreWithScores
     *//*

    public Set<Tuple> zrangeByScoreWithScores(final String key, final double min, final double max) {
        return execute(new JedisAction<Set<Tuple>>() {

            @Override
            public Set<Tuple> action(ShardedJedis jedis) {
                return jedis.zrangeByScoreWithScores(key, min, max);
            }
        });
    }

    */
/**
     * 方法功能说明：返回key的有序集合中的分数在max和min之间的所有元素（包括分数等于max或者min的元素）。与有序集合的默认排序相反，
     * 对于这个命令，元素是从高分到低具有相同分数的元素按字典反序。
     *
     * @param key
     * @param min
     * @param max
     * @return Set<String> 方法名称: zrevgetByScore
     *//*

    public Set<String> zrevrangeByScore(final String key, final double max, final double min) {
        return execute(new JedisAction<Set<String>>() {

            @Override
            public Set<String> action(ShardedJedis jedis) {
                return jedis.zrevrangeByScore(key, max, min);
            }
        });
    }

    */
/**
     * 方法功能说明：返回key的有序集合中的分数在max和min之间的所有元素（包括分数等于max或者min的元素）以及score值。 元素是从高分到低具有相同分数的元素按字典反序。
     *
     * @param key
     * @param min
     * @param max
     * @return Set<Tuple> 方法名称: zrevgetByScoreWithScores
     *//*

    public Set<Tuple> zrevrangeByScoreWithScores(final String key, final double max, final double min) {
        return execute(new JedisAction<Set<Tuple>>() {

            @Override
            public Set<Tuple> action(ShardedJedis jedis) {
                return jedis.zrevrangeByScoreWithScores(key, max, min);
            }
        });
    }

    */
/**
     * 方法功能说明：删除sorted set中的元素，成功删除返回true，key或member不存在返回false。
     *
     * @param key
     * @param member
     * @return boolean 方法名称: zdel
     *//*

    public Boolean zrem(final String key, final String member) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.zrem(key, member) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：移除有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。
     *
     * @param key
     * @param start
     * @param end
     * @return boolean 方法名称: zdelbyscore
     *//*

    public Long zremByScore(final String key, final double start, final double end) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.zremrangeByScore(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：移除有序集key中，指定排名(rank)区间内的所有成员。下标参数start和stop都以0为底，0处是分数最小的那个元素。
     * 这些索引也可是负数，表示位移从最高分处开始数。例如，-1是分数最高的元素，-2是分数第二高的，依次类推。
     *
     * @param key
     * @param start
     * @param end
     * @return boolean 方法名称: zdelbyrank
     *//*

    public Long zremByRank(final String key, final long start, final long end) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.zremrangeByRank(key, start, end);
            }
        });
    }

    */
/**
     * 方法功能说明：返回List长度, key不存在时返回0，key类型不是sorted set时抛出异常.
     *
     * @param key
     * @return long 方法名称: zlen
     *//*

    public Long zcard(final String key) {
        return execute(new JedisAction<Long>() {

            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.zcard(key);
            }
        });
    }

    */
/**
     * 方法功能说明：设置缓存对象过期时间
     *
     * @param key
     * @param seconds
     * @return long 方法名称: expire
     *//*

    public boolean expire(final String key, final int seconds) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.expire(key, seconds) == 1 ? true : false;
            }
        });
    }

    public boolean expire(final byte[] key, final int seconds) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.expire(key, seconds) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：根据UNIX 时间戳(unix timestamp)设置缓存对象过期时间
     *
     * @param key
     * @param unixTime
     * @return long 方法名称: expire
     *//*

    public boolean expireAt(final String key, final long unixTime) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.expireAt(key, unixTime) == 1 ? true : false;
            }
        });
    }

    public boolean expireAt(final byte[] key, final long unixTime) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.expireAt(key, unixTime) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：取消缓存对象的过期时间设置
     *
     * @param key
     * @return boolean 方法名称: persist
     *//*

    public boolean persist(final String key) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.persist(key) == 1 ? true : false;
            }
        });
    }

    */
/**
     * 方法功能说明：根据key判断缓存对象是否存在
     *
     * @param key
     * @return boolean 方法名称: isExisted
     *//*

    public boolean isExisted(final String key) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.exists(key);
            }
        });
    }

    public boolean isExisted(final byte[] key) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(ShardedJedis jedis) {
                return jedis.exists(key);
            }
        });
    }

    */
/**
     * 方法功能说明：对List,Set,SortSet进行排序,如果集合数据较大应避免使用这个方法
     *
     * @param key
     * @return List<String> 方法名称: sort
     *//*

    public List<String> sort(final String key) {
        return execute(new JedisAction<List<String>>() {

            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.sort(key);
            }
        });
    }

    */
/**
     * 方法功能说明：对List,Set,SortSet进行排序或limit
     *
     * @param key
     * @param sortingParams
     * @return List<String> 方法名称: sort
     *//*

    public List<String> sort(final String key, final SortingParams sortingParams) {
        return execute(new JedisAction<List<String>>() {

            @Override
            public List<String> action(ShardedJedis jedis) {
                return jedis.sort(key, sortingParams);
            }
        });
    }

    */
/**
     * 方法功能说明：返回指定key存储的类型
     *
     * @param key
     * @return String 方法名称: type
     *//*

    public String type(final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(ShardedJedis jedis) {
                return jedis.type(key);
            }
        });
    }

    public Long getDateBaseKey(final String appName) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.incr(appName + "_key");
            }
        });
    }

    public void bulkDel(final String setKeysName) {
        Set<String> keys = sget(setKeysName);
        for (Iterator<String> iterator = keys.iterator(); iterator.hasNext(); ) {
            String key = iterator.next();
            del(key);
        }
        del(setKeysName);
    }

    public void bulkDel(final String setKeysName, final String startsWithKeyName) {
        List<String> delKeys = new ArrayList<String>();
        Set<String> keys = sget(setKeysName);
        for (Iterator<String> iterator = keys.iterator(); iterator.hasNext(); ) {
            String key = iterator.next();
            if (key.startsWith(startsWithKeyName)) {
                del(key);
                delKeys.add(key);
            }
        }
        if (delKeys.size() > 0) {
            sdel(setKeysName, delKeys.toArray(new String[]{}));
        }
    }

    public Long getTTL(final String key) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.ttl(key);
            }
        });
    }

    public Long getTTL(final byte[] key) {
        return execute(new JedisAction<Long>() {
            @Override
            public Long action(ShardedJedis jedis) {
                return jedis.ttl(key);
            }
        });
    }

}
*/
